onvibe.run

Talk to Claude and get a live web app deployed to a real URL. onvibe.run is a conversational PaaS: you describe the app you want, Claude builds it through MCP tools, and it ships to a public URL like https://your-project.onvibe.run — no dashboards, no config files, no manual deploys.

What you get with every project

• A live URL instantly. create_project provisions the runtime and deploys a working starter app in one step, returning the live URL right away.
• A PostgreSQL database per project. Run schema migrations and queries straight from the conversation with execute_sql (writes are gated behind an approval step) and query_sql (read-only). Introspect the schema with introspect_schema.
• File storage. Public build-time assets (upload_asset) and private end-user uploads at runtime, served through signed URLs — the patterns are baked into the starter app.
• Scheduled jobs (cron). Define cron jobs in config or via tools (create_cron, list_crons, run_cron, delete_cron); they invoke your app on a schedule.
• Environment variables & secrets. set_env / get_env / delete_env, with encrypted values you paste yourself — secrets never live in source code.
• Transactional email. Send email from your app with send_email.

Safe iteration

• Deploy & edit fast. Change specific parts of a file with edit_file, then deploy staged changes without resending whole files. check_app confirms the app is healthy.
• Versions & rollback. Snapshot code + database with create_version, list them, and rollback_to_version when something breaks. Automatic restore points protect you before risky migrations.
• Drafts (working copies). create_draft clones a running app (code + data) so you can experiment, then apply_changes merges it back with built-in drift detection.
• Observability. Pull runtime logs (get_app_logs) and captured frontend exceptions (get_exceptions) to debug without leaving the conversation.

Forkables — a gallery of ready-to-remix apps

Public projects can be shared as forkables: browse the curated gallery, pick an app, and fork_project gives you your own copy — code, schema, and assets — to build on. Every forkable is a working example you can deploy and customize in minutes.

How it works

The typical flow is: create_project → check_app → read the starter files (list_project_files, read_project_files) → edit_file / deploy → check_app. The starter is a server-rendered app that already models the platform's patterns — PostgreSQL with the right connection setup, private uploads, and automatic frontend error capture — so you have a correct baseline before writing your own code.

Connection

onvibe.run is a remote MCP server over Streamable HTTP with OAuth — no tokens to paste, no local install. Point your client at the endpoint and sign in through your browser on first use.

{
  "mcpServers": {
    "onvibe": {
      "type": "streamable-http",
      "url": "https://onvibe.run/mcp"
    }
  }
}

• Endpoint: https://onvibe.run/mcp
• Transport: Streamable HTTP
• Auth: OAuth 2.0 (PKCE)
• Website: https://onvibe.run

Highlights

• ~35 MCP tools covering the full lifecycle: create, deploy, database, storage, cron, env, versions, drafts, forks, logs, and email.
• Everything happens in the conversation — from first idea to a live, shareable URL.
• Built as a Claude connector: sign in once and start shipping.